#ifndef __Guild_H__
#define __Guild_H__
#include <string>
#include <list>
#include <vector>
#include <map>
#include <cstring>
#include <stdint.h>

//#include "other_idl.h"

struct GuildInfo {
	uint32_t	seq;
	std::string	name;
	uint32_t	master_seq;
	uint64_t	master_socialid;
	std::string	master_nickname;
	std::string	master_profile_url;
	int16_t	master_level;
	int16_t	level;
	int16_t	member_count;
	int16_t	max_member_count;
	int16_t	buff_type;
	int16_t	buff_level;
	int16_t	buff_value;
	int16_t	notice_flag;
	uint64_t	notice_start_time;
	std::string	notice_text;
	std::string	password;
	uint32_t	point;
	uint32_t	max_point;
	uint32_t	prev_point;
	uint32_t	rank;
	uint32_t	prev_rank;
	GuildInfo()	{
		seq = 0;
		master_seq = 0;
		master_socialid = 0;
		master_level = 0;
		level = 0;
		member_count = 0;
		max_member_count = 0;
		buff_type = 0;
		buff_level = 0;
		buff_value = 0;
		notice_flag = 0;
		notice_start_time = 0;
		point = 0;
		max_point = 0;
		prev_point = 0;
		rank = 0;
		prev_rank = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t); nSize += name.length();
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t); nSize += master_nickname.length();
		nSize += sizeof(uint32_t); nSize += master_profile_url.length();
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t); nSize += notice_text.length();
		nSize += sizeof(uint32_t); nSize += password.length();
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		size_t name_size = name.length();
		std::memcpy(*_buf_, &name_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, name.c_str(), name.length()); (*_buf_) += name.length();
		std::memcpy(*_buf_, &master_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &master_socialid, sizeof(uint64_t)); (*_buf_) += sizeof(uint64_t);
		size_t master_nickname_size = master_nickname.length();
		std::memcpy(*_buf_, &master_nickname_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, master_nickname.c_str(), master_nickname.length()); (*_buf_) += master_nickname.length();
		size_t master_profile_url_size = master_profile_url.length();
		std::memcpy(*_buf_, &master_profile_url_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, master_profile_url.c_str(), master_profile_url.length()); (*_buf_) += master_profile_url.length();
		std::memcpy(*_buf_, &master_level, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &level, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &member_count, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &max_member_count, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &buff_type, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &buff_level, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &buff_value, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &notice_flag, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &notice_start_time, sizeof(uint64_t)); (*_buf_) += sizeof(uint64_t);
		size_t notice_text_size = notice_text.length();
		std::memcpy(*_buf_, &notice_text_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, notice_text.c_str(), notice_text.length()); (*_buf_) += notice_text.length();
		size_t password_size = password.length();
		std::memcpy(*_buf_, &password_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, password.c_str(), password.length()); (*_buf_) += password.length();
		std::memcpy(*_buf_, &point, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &max_point, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &prev_point, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &rank, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &prev_rank, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t name_length = 0; std::memcpy(&name_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < name_length) { return false; }
		name.assign((char*)*_buf_, name_length); (*_buf_) += name_length; nSize -= name_length;
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&master_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&master_socialid, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t master_nickname_length = 0; std::memcpy(&master_nickname_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < master_nickname_length) { return false; }
		master_nickname.assign((char*)*_buf_, master_nickname_length); (*_buf_) += master_nickname_length; nSize -= master_nickname_length;
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t master_profile_url_length = 0; std::memcpy(&master_profile_url_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < master_profile_url_length) { return false; }
		master_profile_url.assign((char*)*_buf_, master_profile_url_length); (*_buf_) += master_profile_url_length; nSize -= master_profile_url_length;
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&master_level, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&level, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&member_count, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&max_member_count, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&buff_type, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&buff_level, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&buff_value, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&notice_flag, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&notice_start_time, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t notice_text_length = 0; std::memcpy(&notice_text_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < notice_text_length) { return false; }
		notice_text.assign((char*)*_buf_, notice_text_length); (*_buf_) += notice_text_length; nSize -= notice_text_length;
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t password_length = 0; std::memcpy(&password_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < password_length) { return false; }
		password.assign((char*)*_buf_, password_length); (*_buf_) += password_length; nSize -= password_length;
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&point, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&max_point, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&prev_point, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&rank, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&prev_rank, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GuildInfo
struct GuildInfo_Serializer {
	static bool Store(char** _buf_, const GuildInfo& obj) { return obj.Store(_buf_); }
	static bool Load(GuildInfo& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildInfo& obj) { return obj.Size(); }
};
struct GuildMemberInfo {
	uint32_t	seq;
	uint64_t	socialid;
	std::string	nickname;
	std::string	profile_url;
	int16_t	level;
	int16_t	server_id;
	uint32_t	point;
	int16_t	guild_grade;
	int16_t	logout_period;
	int16_t	requestToLogin;
	GuildMemberInfo()	{
		seq = 0;
		socialid = 0;
		level = 0;
		server_id = 0;
		point = 0;
		guild_grade = 0;
		logout_period = 0;
		requestToLogin = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t); nSize += nickname.length();
		nSize += sizeof(uint32_t); nSize += profile_url.length();
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &socialid, sizeof(uint64_t)); (*_buf_) += sizeof(uint64_t);
		size_t nickname_size = nickname.length();
		std::memcpy(*_buf_, &nickname_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, nickname.c_str(), nickname.length()); (*_buf_) += nickname.length();
		size_t profile_url_size = profile_url.length();
		std::memcpy(*_buf_, &profile_url_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, profile_url.c_str(), profile_url.length()); (*_buf_) += profile_url.length();
		std::memcpy(*_buf_, &level, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &server_id, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &point, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_grade, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &logout_period, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &requestToLogin, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&socialid, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t nickname_length = 0; std::memcpy(&nickname_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < nickname_length) { return false; }
		nickname.assign((char*)*_buf_, nickname_length); (*_buf_) += nickname_length; nSize -= nickname_length;
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t profile_url_length = 0; std::memcpy(&profile_url_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < profile_url_length) { return false; }
		profile_url.assign((char*)*_buf_, profile_url_length); (*_buf_) += profile_url_length; nSize -= profile_url_length;
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&level, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&server_id, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&point, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&guild_grade, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&logout_period, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&requestToLogin, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //GuildMemberInfo
struct GuildMemberInfo_Serializer {
	static bool Store(char** _buf_, const GuildMemberInfo& obj) { return obj.Store(_buf_); }
	static bool Load(GuildMemberInfo& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildMemberInfo& obj) { return obj.Size(); }
};
struct GuildOpenAck {
	enum { MSG_ID = 1 }; 
	GuildOpenAck()	{
	}
	int32_t Size() const {
		int32_t nSize = 0;
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		return true;
	}
}; //GuildOpenAck
struct GuildOpenAck_Serializer {
	static bool Store(char** _buf_, const GuildOpenAck& obj) { return obj.Store(_buf_); }
	static bool Load(GuildOpenAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildOpenAck& obj) { return obj.Size(); }
};
struct GuildCloseAck {
	enum { MSG_ID = 2 }; 
	GuildCloseAck()	{
	}
	int32_t Size() const {
		int32_t nSize = 0;
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		return true;
	}
}; //GuildCloseAck
struct GuildCloseAck_Serializer {
	static bool Store(char** _buf_, const GuildCloseAck& obj) { return obj.Store(_buf_); }
	static bool Load(GuildCloseAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildCloseAck& obj) { return obj.Size(); }
};
struct GuildInfoSyn {
	enum { MSG_ID = 6001 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	GuildInfoSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GuildInfoSyn
struct GuildInfoSyn_Serializer {
	static bool Store(char** _buf_, const GuildInfoSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GuildInfoSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildInfoSyn& obj) { return obj.Size(); }
};
struct GuildInfoAck {
	enum { MSG_ID = 6002 }; 
	uint32_t	user_seq;
	int16_t	result;
	GuildInfo	stInfo;
	GuildInfoAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += GuildInfo_Serializer::Size(stInfo);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		if(false == GuildInfo_Serializer::Store(_buf_, stInfo)) { return false; }
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(false == GuildInfo_Serializer::Load(stInfo, _buf_, nSize)) { return false; }
		return true;
	}
}; //GuildInfoAck
struct GuildInfoAck_Serializer {
	static bool Store(char** _buf_, const GuildInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(GuildInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildInfoAck& obj) { return obj.Size(); }
};
struct GuildMemberSyn {
	enum { MSG_ID = 6003 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	GuildMemberSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GuildMemberSyn
struct GuildMemberSyn_Serializer {
	static bool Store(char** _buf_, const GuildMemberSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GuildMemberSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildMemberSyn& obj) { return obj.Size(); }
};
struct GuildMemberAck {
	enum { MSG_ID = 6004 }; 
	uint32_t	user_seq;
	int16_t	result;
	std::vector<GuildMemberInfo >	array_members;
	GuildMemberAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int32_t);
		for(std::vector<GuildMemberInfo >::const_iterator array_members_itr = array_members.begin(); array_members_itr != array_members.end(); array_members_itr++)	{
			const GuildMemberInfo& array_members_elmt = *array_members_itr;
			nSize += GuildMemberInfo_Serializer::Size(array_members_elmt);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		size_t array_members_size = array_members.size();
		std::memcpy(*_buf_, &array_members_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		for(std::vector<GuildMemberInfo >::const_iterator array_members_itr = array_members.begin(); array_members_itr != array_members.end(); array_members_itr++)	{
			const GuildMemberInfo& array_members_elmt = *array_members_itr;
			if(false == GuildMemberInfo_Serializer::Store(_buf_, array_members_elmt)) { return false; }
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t array_members_length = 0; std::memcpy(&array_members_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		for(uint32_t i=0; i<array_members_length; i++) {
			GuildMemberInfo array_members_val;
			if(false == GuildMemberInfo_Serializer::Load(array_members_val, _buf_, nSize)) { return false; }
			array_members.push_back(array_members_val);
		}
		return true;
	}
}; //GuildMemberAck
struct GuildMemberAck_Serializer {
	static bool Store(char** _buf_, const GuildMemberAck& obj) { return obj.Store(_buf_); }
	static bool Load(GuildMemberAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildMemberAck& obj) { return obj.Size(); }
};
struct LoginGuildMemberSyn {
	enum { MSG_ID = 6005 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	uint64_t	socialid;
	std::string	nickname;
	std::string	profile_url;
	int16_t	level;
	int16_t	server_id;
	LoginGuildMemberSyn()	{
		user_seq = 0;
		guild_seq = 0;
		socialid = 0;
		level = 0;
		server_id = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t); nSize += nickname.length();
		nSize += sizeof(uint32_t); nSize += profile_url.length();
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &socialid, sizeof(uint64_t)); (*_buf_) += sizeof(uint64_t);
		size_t nickname_size = nickname.length();
		std::memcpy(*_buf_, &nickname_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, nickname.c_str(), nickname.length()); (*_buf_) += nickname.length();
		size_t profile_url_size = profile_url.length();
		std::memcpy(*_buf_, &profile_url_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, profile_url.c_str(), profile_url.length()); (*_buf_) += profile_url.length();
		std::memcpy(*_buf_, &level, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &server_id, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&socialid, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t nickname_length = 0; std::memcpy(&nickname_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < nickname_length) { return false; }
		nickname.assign((char*)*_buf_, nickname_length); (*_buf_) += nickname_length; nSize -= nickname_length;
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t profile_url_length = 0; std::memcpy(&profile_url_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < profile_url_length) { return false; }
		profile_url.assign((char*)*_buf_, profile_url_length); (*_buf_) += profile_url_length; nSize -= profile_url_length;
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&level, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&server_id, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //LoginGuildMemberSyn
struct LoginGuildMemberSyn_Serializer {
	static bool Store(char** _buf_, const LoginGuildMemberSyn& obj) { return obj.Store(_buf_); }
	static bool Load(LoginGuildMemberSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const LoginGuildMemberSyn& obj) { return obj.Size(); }
};
struct MyGuildInfoAck {
	enum { MSG_ID = 6006 }; 
	uint32_t	user_seq;
	int16_t	result;
	GuildInfo	stInfo;
	MyGuildInfoAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += GuildInfo_Serializer::Size(stInfo);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		if(false == GuildInfo_Serializer::Store(_buf_, stInfo)) { return false; }
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(false == GuildInfo_Serializer::Load(stInfo, _buf_, nSize)) { return false; }
		return true;
	}
}; //MyGuildInfoAck
struct MyGuildInfoAck_Serializer {
	static bool Store(char** _buf_, const MyGuildInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(MyGuildInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const MyGuildInfoAck& obj) { return obj.Size(); }
};
struct LogoutGuildMemberSyn {
	enum { MSG_ID = 6007 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	LogoutGuildMemberSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //LogoutGuildMemberSyn
struct LogoutGuildMemberSyn_Serializer {
	static bool Store(char** _buf_, const LogoutGuildMemberSyn& obj) { return obj.Store(_buf_); }
	static bool Load(LogoutGuildMemberSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const LogoutGuildMemberSyn& obj) { return obj.Size(); }
};
struct RecoverGuildAck {
	enum { MSG_ID = 6009 }; 
	uint32_t	user_seq;
	int16_t	result;
	GuildInfo	stInfo;
	RecoverGuildAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += GuildInfo_Serializer::Size(stInfo);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		if(false == GuildInfo_Serializer::Store(_buf_, stInfo)) { return false; }
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(false == GuildInfo_Serializer::Load(stInfo, _buf_, nSize)) { return false; }
		return true;
	}
}; //RecoverGuildAck
struct RecoverGuildAck_Serializer {
	static bool Store(char** _buf_, const RecoverGuildAck& obj) { return obj.Store(_buf_); }
	static bool Load(RecoverGuildAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const RecoverGuildAck& obj) { return obj.Size(); }
};
struct CreateGuildSyn {
	enum { MSG_ID = 6011 }; 
	uint32_t	user_seq;
	uint32_t	gold;
	int16_t	level;
	std::string	guild_name;
	std::string	password;
	std::string	notice_text;
	uint64_t	socialid;
	std::string	nickname;
	std::string	profile_url;
	int16_t	exposure;
	int16_t	server_id;
	CreateGuildSyn()	{
		user_seq = 0;
		gold = 0;
		level = 0;
		socialid = 0;
		exposure = 0;
		server_id = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t); nSize += guild_name.length();
		nSize += sizeof(uint32_t); nSize += password.length();
		nSize += sizeof(uint32_t); nSize += notice_text.length();
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t); nSize += nickname.length();
		nSize += sizeof(uint32_t); nSize += profile_url.length();
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &gold, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &level, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		size_t guild_name_size = guild_name.length();
		std::memcpy(*_buf_, &guild_name_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, guild_name.c_str(), guild_name.length()); (*_buf_) += guild_name.length();
		size_t password_size = password.length();
		std::memcpy(*_buf_, &password_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, password.c_str(), password.length()); (*_buf_) += password.length();
		size_t notice_text_size = notice_text.length();
		std::memcpy(*_buf_, &notice_text_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, notice_text.c_str(), notice_text.length()); (*_buf_) += notice_text.length();
		std::memcpy(*_buf_, &socialid, sizeof(uint64_t)); (*_buf_) += sizeof(uint64_t);
		size_t nickname_size = nickname.length();
		std::memcpy(*_buf_, &nickname_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, nickname.c_str(), nickname.length()); (*_buf_) += nickname.length();
		size_t profile_url_size = profile_url.length();
		std::memcpy(*_buf_, &profile_url_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, profile_url.c_str(), profile_url.length()); (*_buf_) += profile_url.length();
		std::memcpy(*_buf_, &exposure, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &server_id, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gold, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&level, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t guild_name_length = 0; std::memcpy(&guild_name_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < guild_name_length) { return false; }
		guild_name.assign((char*)*_buf_, guild_name_length); (*_buf_) += guild_name_length; nSize -= guild_name_length;
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t password_length = 0; std::memcpy(&password_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < password_length) { return false; }
		password.assign((char*)*_buf_, password_length); (*_buf_) += password_length; nSize -= password_length;
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t notice_text_length = 0; std::memcpy(&notice_text_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < notice_text_length) { return false; }
		notice_text.assign((char*)*_buf_, notice_text_length); (*_buf_) += notice_text_length; nSize -= notice_text_length;
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&socialid, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t nickname_length = 0; std::memcpy(&nickname_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < nickname_length) { return false; }
		nickname.assign((char*)*_buf_, nickname_length); (*_buf_) += nickname_length; nSize -= nickname_length;
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t profile_url_length = 0; std::memcpy(&profile_url_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < profile_url_length) { return false; }
		profile_url.assign((char*)*_buf_, profile_url_length); (*_buf_) += profile_url_length; nSize -= profile_url_length;
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&exposure, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&server_id, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //CreateGuildSyn
struct CreateGuildSyn_Serializer {
	static bool Store(char** _buf_, const CreateGuildSyn& obj) { return obj.Store(_buf_); }
	static bool Load(CreateGuildSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const CreateGuildSyn& obj) { return obj.Size(); }
};
struct CreateGuildAck {
	enum { MSG_ID = 6012 }; 
	uint32_t	user_seq;
	int16_t	result;
	uint32_t	guild_seq;
	uint16_t	guild_grade;
	std::string	guild_name;
	uint32_t	guild_create_gold;
	CreateGuildAck()	{
		user_seq = 0;
		result = 0;
		guild_seq = 0;
		guild_grade = 0;
		guild_create_gold = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint32_t); nSize += guild_name.length();
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_grade, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		size_t guild_name_size = guild_name.length();
		std::memcpy(*_buf_, &guild_name_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, guild_name.c_str(), guild_name.length()); (*_buf_) += guild_name.length();
		std::memcpy(*_buf_, &guild_create_gold, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&guild_grade, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t guild_name_length = 0; std::memcpy(&guild_name_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < guild_name_length) { return false; }
		guild_name.assign((char*)*_buf_, guild_name_length); (*_buf_) += guild_name_length; nSize -= guild_name_length;
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_create_gold, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //CreateGuildAck
struct CreateGuildAck_Serializer {
	static bool Store(char** _buf_, const CreateGuildAck& obj) { return obj.Store(_buf_); }
	static bool Load(CreateGuildAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const CreateGuildAck& obj) { return obj.Size(); }
};
struct JoinGuildSyn {
	enum { MSG_ID = 60013 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	std::string	password;
	uint64_t	socialid;
	std::string	nickname;
	std::string	profile_url;
	int16_t	level;
	int16_t	server_id;
	JoinGuildSyn()	{
		user_seq = 0;
		guild_seq = 0;
		socialid = 0;
		level = 0;
		server_id = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t); nSize += password.length();
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t); nSize += nickname.length();
		nSize += sizeof(uint32_t); nSize += profile_url.length();
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		size_t password_size = password.length();
		std::memcpy(*_buf_, &password_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, password.c_str(), password.length()); (*_buf_) += password.length();
		std::memcpy(*_buf_, &socialid, sizeof(uint64_t)); (*_buf_) += sizeof(uint64_t);
		size_t nickname_size = nickname.length();
		std::memcpy(*_buf_, &nickname_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, nickname.c_str(), nickname.length()); (*_buf_) += nickname.length();
		size_t profile_url_size = profile_url.length();
		std::memcpy(*_buf_, &profile_url_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, profile_url.c_str(), profile_url.length()); (*_buf_) += profile_url.length();
		std::memcpy(*_buf_, &level, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &server_id, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t password_length = 0; std::memcpy(&password_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < password_length) { return false; }
		password.assign((char*)*_buf_, password_length); (*_buf_) += password_length; nSize -= password_length;
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&socialid, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t nickname_length = 0; std::memcpy(&nickname_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < nickname_length) { return false; }
		nickname.assign((char*)*_buf_, nickname_length); (*_buf_) += nickname_length; nSize -= nickname_length;
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t profile_url_length = 0; std::memcpy(&profile_url_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < profile_url_length) { return false; }
		profile_url.assign((char*)*_buf_, profile_url_length); (*_buf_) += profile_url_length; nSize -= profile_url_length;
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&level, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&server_id, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //JoinGuildSyn
struct JoinGuildSyn_Serializer {
	static bool Store(char** _buf_, const JoinGuildSyn& obj) { return obj.Store(_buf_); }
	static bool Load(JoinGuildSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const JoinGuildSyn& obj) { return obj.Size(); }
};
struct JoinGuildAck {
	enum { MSG_ID = 60014 }; 
	uint32_t	user_seq;
	int16_t	result;
	uint32_t	guild_seq;
	uint16_t	guild_grade;
	std::string	guild_name;
	uint16_t	buff_tid;
	uint16_t	buff_level;
	uint16_t	buff_value;
	JoinGuildAck()	{
		user_seq = 0;
		result = 0;
		guild_seq = 0;
		guild_grade = 0;
		buff_tid = 0;
		buff_level = 0;
		buff_value = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint32_t); nSize += guild_name.length();
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_grade, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		size_t guild_name_size = guild_name.length();
		std::memcpy(*_buf_, &guild_name_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, guild_name.c_str(), guild_name.length()); (*_buf_) += guild_name.length();
		std::memcpy(*_buf_, &buff_tid, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		std::memcpy(*_buf_, &buff_level, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		std::memcpy(*_buf_, &buff_value, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&guild_grade, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t guild_name_length = 0; std::memcpy(&guild_name_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < guild_name_length) { return false; }
		guild_name.assign((char*)*_buf_, guild_name_length); (*_buf_) += guild_name_length; nSize -= guild_name_length;
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&buff_tid, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&buff_level, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&buff_value, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //JoinGuildAck
struct JoinGuildAck_Serializer {
	static bool Store(char** _buf_, const JoinGuildAck& obj) { return obj.Store(_buf_); }
	static bool Load(JoinGuildAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const JoinGuildAck& obj) { return obj.Size(); }
};
struct LeaveGuildSyn {
	enum { MSG_ID = 60017 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	LeaveGuildSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //LeaveGuildSyn
struct LeaveGuildSyn_Serializer {
	static bool Store(char** _buf_, const LeaveGuildSyn& obj) { return obj.Store(_buf_); }
	static bool Load(LeaveGuildSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const LeaveGuildSyn& obj) { return obj.Size(); }
};
struct LeaveGuildAck {
	enum { MSG_ID = 60018 }; 
	uint32_t	user_seq;
	int16_t	result;
	LeaveGuildAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //LeaveGuildAck
struct LeaveGuildAck_Serializer {
	static bool Store(char** _buf_, const LeaveGuildAck& obj) { return obj.Store(_buf_); }
	static bool Load(LeaveGuildAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const LeaveGuildAck& obj) { return obj.Size(); }
};
struct KickoutGuildMemberSyn {
	enum { MSG_ID = 60021 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	uint32_t	member_seq;
	KickoutGuildMemberSyn()	{
		user_seq = 0;
		guild_seq = 0;
		member_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &member_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&member_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //KickoutGuildMemberSyn
struct KickoutGuildMemberSyn_Serializer {
	static bool Store(char** _buf_, const KickoutGuildMemberSyn& obj) { return obj.Store(_buf_); }
	static bool Load(KickoutGuildMemberSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const KickoutGuildMemberSyn& obj) { return obj.Size(); }
};
struct KickoutGuildMemberAck {
	enum { MSG_ID = 60022 }; 
	uint32_t	user_seq;
	int16_t	result;
	uint32_t	guild_point;
	KickoutGuildMemberAck()	{
		user_seq = 0;
		result = 0;
		guild_point = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &guild_point, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_point, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //KickoutGuildMemberAck
struct KickoutGuildMemberAck_Serializer {
	static bool Store(char** _buf_, const KickoutGuildMemberAck& obj) { return obj.Store(_buf_); }
	static bool Load(KickoutGuildMemberAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const KickoutGuildMemberAck& obj) { return obj.Size(); }
};
struct GuildListSyn {
	enum { MSG_ID = 60031 }; 
	uint32_t	user_seq;
	int16_t	type;
	int16_t	page;
	GuildListSyn()	{
		user_seq = 0;
		type = 0;
		page = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &type, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &page, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&type, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&page, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //GuildListSyn
struct GuildListSyn_Serializer {
	static bool Store(char** _buf_, const GuildListSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GuildListSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildListSyn& obj) { return obj.Size(); }
};
struct GuildListAck {
	enum { MSG_ID = 60032 }; 
	uint32_t	user_seq;
	int16_t	result;
	int16_t	type;
	std::vector<GuildInfo >	array_Guilds;
	GuildListAck()	{
		user_seq = 0;
		result = 0;
		type = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int32_t);
		for(std::vector<GuildInfo >::const_iterator array_Guilds_itr = array_Guilds.begin(); array_Guilds_itr != array_Guilds.end(); array_Guilds_itr++)	{
			const GuildInfo& array_Guilds_elmt = *array_Guilds_itr;
			nSize += GuildInfo_Serializer::Size(array_Guilds_elmt);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &type, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		size_t array_Guilds_size = array_Guilds.size();
		std::memcpy(*_buf_, &array_Guilds_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		for(std::vector<GuildInfo >::const_iterator array_Guilds_itr = array_Guilds.begin(); array_Guilds_itr != array_Guilds.end(); array_Guilds_itr++)	{
			const GuildInfo& array_Guilds_elmt = *array_Guilds_itr;
			if(false == GuildInfo_Serializer::Store(_buf_, array_Guilds_elmt)) { return false; }
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&type, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t array_Guilds_length = 0; std::memcpy(&array_Guilds_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		for(uint32_t i=0; i<array_Guilds_length; i++) {
			GuildInfo array_Guilds_val;
			if(false == GuildInfo_Serializer::Load(array_Guilds_val, _buf_, nSize)) { return false; }
			array_Guilds.push_back(array_Guilds_val);
		}
		return true;
	}
}; //GuildListAck
struct GuildListAck_Serializer {
	static bool Store(char** _buf_, const GuildListAck& obj) { return obj.Store(_buf_); }
	static bool Load(GuildListAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildListAck& obj) { return obj.Size(); }
};
struct SearchGuildSyn {
	enum { MSG_ID = 60035 }; 
	uint32_t	user_seq;
	std::string	guild_name;
	SearchGuildSyn()	{
		user_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t); nSize += guild_name.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		size_t guild_name_size = guild_name.length();
		std::memcpy(*_buf_, &guild_name_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, guild_name.c_str(), guild_name.length()); (*_buf_) += guild_name.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t guild_name_length = 0; std::memcpy(&guild_name_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < guild_name_length) { return false; }
		guild_name.assign((char*)*_buf_, guild_name_length); (*_buf_) += guild_name_length; nSize -= guild_name_length;
		return true;
	}
}; //SearchGuildSyn
struct SearchGuildSyn_Serializer {
	static bool Store(char** _buf_, const SearchGuildSyn& obj) { return obj.Store(_buf_); }
	static bool Load(SearchGuildSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SearchGuildSyn& obj) { return obj.Size(); }
};
struct SearchGuildAck {
	enum { MSG_ID = 60036 }; 
	uint32_t	user_seq;
	int16_t	result;
	std::vector<GuildInfo >	array_Guilds;
	SearchGuildAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int32_t);
		for(std::vector<GuildInfo >::const_iterator array_Guilds_itr = array_Guilds.begin(); array_Guilds_itr != array_Guilds.end(); array_Guilds_itr++)	{
			const GuildInfo& array_Guilds_elmt = *array_Guilds_itr;
			nSize += GuildInfo_Serializer::Size(array_Guilds_elmt);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		size_t array_Guilds_size = array_Guilds.size();
		std::memcpy(*_buf_, &array_Guilds_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		for(std::vector<GuildInfo >::const_iterator array_Guilds_itr = array_Guilds.begin(); array_Guilds_itr != array_Guilds.end(); array_Guilds_itr++)	{
			const GuildInfo& array_Guilds_elmt = *array_Guilds_itr;
			if(false == GuildInfo_Serializer::Store(_buf_, array_Guilds_elmt)) { return false; }
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t array_Guilds_length = 0; std::memcpy(&array_Guilds_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		for(uint32_t i=0; i<array_Guilds_length; i++) {
			GuildInfo array_Guilds_val;
			if(false == GuildInfo_Serializer::Load(array_Guilds_val, _buf_, nSize)) { return false; }
			array_Guilds.push_back(array_Guilds_val);
		}
		return true;
	}
}; //SearchGuildAck
struct SearchGuildAck_Serializer {
	static bool Store(char** _buf_, const SearchGuildAck& obj) { return obj.Store(_buf_); }
	static bool Load(SearchGuildAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SearchGuildAck& obj) { return obj.Size(); }
};
struct GuildChatSyn {
	enum { MSG_ID = 60037 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	std::string	chat;
	GuildChatSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t); nSize += chat.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		size_t chat_size = chat.length();
		std::memcpy(*_buf_, &chat_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, chat.c_str(), chat.length()); (*_buf_) += chat.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t chat_length = 0; std::memcpy(&chat_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < chat_length) { return false; }
		chat.assign((char*)*_buf_, chat_length); (*_buf_) += chat_length; nSize -= chat_length;
		return true;
	}
}; //GuildChatSyn
struct GuildChatSyn_Serializer {
	static bool Store(char** _buf_, const GuildChatSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GuildChatSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildChatSyn& obj) { return obj.Size(); }
};
struct BroadcastGuildChatAck {
	enum { MSG_ID = 60038 }; 
	uint32_t	user_seq;
	int16_t	result;
	std::string	nickname;
	std::string	chat;
	std::vector<uint32_t >	array_Members;
	BroadcastGuildChatAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t); nSize += nickname.length();
		nSize += sizeof(uint32_t); nSize += chat.length();
		nSize += sizeof(int32_t);
		for(std::vector<uint32_t >::const_iterator array_Members_itr = array_Members.begin(); array_Members_itr != array_Members.end(); array_Members_itr++)	{
			nSize += sizeof(uint32_t);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		size_t nickname_size = nickname.length();
		std::memcpy(*_buf_, &nickname_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, nickname.c_str(), nickname.length()); (*_buf_) += nickname.length();
		size_t chat_size = chat.length();
		std::memcpy(*_buf_, &chat_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, chat.c_str(), chat.length()); (*_buf_) += chat.length();
		size_t array_Members_size = array_Members.size();
		std::memcpy(*_buf_, &array_Members_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		for(std::vector<uint32_t >::const_iterator array_Members_itr = array_Members.begin(); array_Members_itr != array_Members.end(); array_Members_itr++)	{
			const uint32_t& array_Members_elmt = *array_Members_itr;
			std::memcpy(*_buf_, &array_Members_elmt, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t nickname_length = 0; std::memcpy(&nickname_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < nickname_length) { return false; }
		nickname.assign((char*)*_buf_, nickname_length); (*_buf_) += nickname_length; nSize -= nickname_length;
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t chat_length = 0; std::memcpy(&chat_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < chat_length) { return false; }
		chat.assign((char*)*_buf_, chat_length); (*_buf_) += chat_length; nSize -= chat_length;
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t array_Members_length = 0; std::memcpy(&array_Members_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		for(uint32_t i=0; i<array_Members_length; i++) {
			uint32_t array_Members_val;
			if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&array_Members_val, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
			array_Members.push_back(array_Members_val);
		}
		return true;
	}
}; //BroadcastGuildChatAck
struct BroadcastGuildChatAck_Serializer {
	static bool Store(char** _buf_, const BroadcastGuildChatAck& obj) { return obj.Store(_buf_); }
	static bool Load(BroadcastGuildChatAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const BroadcastGuildChatAck& obj) { return obj.Size(); }
};
struct UpdateGuildLevelSyn {
	enum { MSG_ID = 60039 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	UpdateGuildLevelSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //UpdateGuildLevelSyn
struct UpdateGuildLevelSyn_Serializer {
	static bool Store(char** _buf_, const UpdateGuildLevelSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildLevelSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildLevelSyn& obj) { return obj.Size(); }
};
struct UpdateGuildLevelAck {
	enum { MSG_ID = 60040 }; 
	uint32_t	user_seq;
	int16_t	result;
	int16_t	level;
	uint32_t	point;
	uint32_t	next_level_point;
	UpdateGuildLevelAck()	{
		user_seq = 0;
		result = 0;
		level = 0;
		point = 0;
		next_level_point = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &level, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &point, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &next_level_point, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&level, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&point, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&next_level_point, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //UpdateGuildLevelAck
struct UpdateGuildLevelAck_Serializer {
	static bool Store(char** _buf_, const UpdateGuildLevelAck& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildLevelAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildLevelAck& obj) { return obj.Size(); }
};
struct GuildBuffGachyaSyn {
	enum { MSG_ID = 60041 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	GuildBuffGachyaSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GuildBuffGachyaSyn
struct GuildBuffGachyaSyn_Serializer {
	static bool Store(char** _buf_, const GuildBuffGachyaSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GuildBuffGachyaSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildBuffGachyaSyn& obj) { return obj.Size(); }
};
struct GuildBuffGachyaAck {
	enum { MSG_ID = 60042 }; 
	uint32_t	user_seq;
	int16_t	result;
	uint16_t	buff_tid;
	uint16_t	buff_level;
	uint16_t	buff_value;
	GuildBuffGachyaAck()	{
		user_seq = 0;
		result = 0;
		buff_tid = 0;
		buff_level = 0;
		buff_value = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &buff_tid, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		std::memcpy(*_buf_, &buff_level, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		std::memcpy(*_buf_, &buff_value, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&buff_tid, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&buff_level, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&buff_value, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //GuildBuffGachyaAck
struct GuildBuffGachyaAck_Serializer {
	static bool Store(char** _buf_, const GuildBuffGachyaAck& obj) { return obj.Store(_buf_); }
	static bool Load(GuildBuffGachyaAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildBuffGachyaAck& obj) { return obj.Size(); }
};
struct UpdateGuildJoinPasswordSyn {
	enum { MSG_ID = 60043 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	std::string	password;
	UpdateGuildJoinPasswordSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t); nSize += password.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		size_t password_size = password.length();
		std::memcpy(*_buf_, &password_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, password.c_str(), password.length()); (*_buf_) += password.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t password_length = 0; std::memcpy(&password_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < password_length) { return false; }
		password.assign((char*)*_buf_, password_length); (*_buf_) += password_length; nSize -= password_length;
		return true;
	}
}; //UpdateGuildJoinPasswordSyn
struct UpdateGuildJoinPasswordSyn_Serializer {
	static bool Store(char** _buf_, const UpdateGuildJoinPasswordSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildJoinPasswordSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildJoinPasswordSyn& obj) { return obj.Size(); }
};
struct UpdateGuildJoinPasswordAck {
	enum { MSG_ID = 60044 }; 
	uint32_t	user_seq;
	int16_t	result;
	UpdateGuildJoinPasswordAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //UpdateGuildJoinPasswordAck
struct UpdateGuildJoinPasswordAck_Serializer {
	static bool Store(char** _buf_, const UpdateGuildJoinPasswordAck& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildJoinPasswordAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildJoinPasswordAck& obj) { return obj.Size(); }
};
struct UpdateGuildNoticeSyn {
	enum { MSG_ID = 60045 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	int16_t	flag;
	UpdateGuildNoticeSyn()	{
		user_seq = 0;
		guild_seq = 0;
		flag = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &flag, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&flag, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //UpdateGuildNoticeSyn
struct UpdateGuildNoticeSyn_Serializer {
	static bool Store(char** _buf_, const UpdateGuildNoticeSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildNoticeSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildNoticeSyn& obj) { return obj.Size(); }
};
struct UpdateGuildNoticeAck {
	enum { MSG_ID = 60046 }; 
	uint32_t	user_seq;
	int16_t	result;
	UpdateGuildNoticeAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //UpdateGuildNoticeAck
struct UpdateGuildNoticeAck_Serializer {
	static bool Store(char** _buf_, const UpdateGuildNoticeAck& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildNoticeAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildNoticeAck& obj) { return obj.Size(); }
};
struct UpdateGuildNoticeTextSyn {
	enum { MSG_ID = 60047 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	std::string	text;
	UpdateGuildNoticeTextSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t); nSize += text.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		size_t text_size = text.length();
		std::memcpy(*_buf_, &text_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, text.c_str(), text.length()); (*_buf_) += text.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t text_length = 0; std::memcpy(&text_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < text_length) { return false; }
		text.assign((char*)*_buf_, text_length); (*_buf_) += text_length; nSize -= text_length;
		return true;
	}
}; //UpdateGuildNoticeTextSyn
struct UpdateGuildNoticeTextSyn_Serializer {
	static bool Store(char** _buf_, const UpdateGuildNoticeTextSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildNoticeTextSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildNoticeTextSyn& obj) { return obj.Size(); }
};
struct UpdateGuildNoticeTextAck {
	enum { MSG_ID = 60048 }; 
	uint32_t	user_seq;
	int16_t	result;
	UpdateGuildNoticeTextAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //UpdateGuildNoticeTextAck
struct UpdateGuildNoticeTextAck_Serializer {
	static bool Store(char** _buf_, const UpdateGuildNoticeTextAck& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildNoticeTextAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildNoticeTextAck& obj) { return obj.Size(); }
};
struct UpdateGuildPointSyn {
	enum { MSG_ID = 60049 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	int16_t	point;
	UpdateGuildPointSyn()	{
		user_seq = 0;
		guild_seq = 0;
		point = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &point, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&point, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //UpdateGuildPointSyn
struct UpdateGuildPointSyn_Serializer {
	static bool Store(char** _buf_, const UpdateGuildPointSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildPointSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildPointSyn& obj) { return obj.Size(); }
};
struct UpdateGuildPointAck {
	enum { MSG_ID = 60050 }; 
	uint32_t	user_seq;
	int16_t	result;
	UpdateGuildPointAck()	{
		user_seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //UpdateGuildPointAck
struct UpdateGuildPointAck_Serializer {
	static bool Store(char** _buf_, const UpdateGuildPointAck& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildPointAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildPointAck& obj) { return obj.Size(); }
};
struct ReloadResourceSyn {
	enum { MSG_ID = 60051 }; 
	ReloadResourceSyn()	{
	}
	int32_t Size() const {
		int32_t nSize = 0;
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		return true;
	}
}; //ReloadResourceSyn
struct ReloadResourceSyn_Serializer {
	static bool Store(char** _buf_, const ReloadResourceSyn& obj) { return obj.Store(_buf_); }
	static bool Load(ReloadResourceSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const ReloadResourceSyn& obj) { return obj.Size(); }
};
struct ApplyGuildPointSyn {
	enum { MSG_ID = 60052 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	uint16_t	contents;
	uint16_t	value;
	ApplyGuildPointSyn()	{
		user_seq = 0;
		guild_seq = 0;
		contents = 0;
		value = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &contents, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		std::memcpy(*_buf_, &value, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&contents, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&value, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //ApplyGuildPointSyn
struct ApplyGuildPointSyn_Serializer {
	static bool Store(char** _buf_, const ApplyGuildPointSyn& obj) { return obj.Store(_buf_); }
	static bool Load(ApplyGuildPointSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const ApplyGuildPointSyn& obj) { return obj.Size(); }
};
struct GuildCoolDownSyn {
	enum { MSG_ID = 60053 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	GuildCoolDownSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GuildCoolDownSyn
struct GuildCoolDownSyn_Serializer {
	static bool Store(char** _buf_, const GuildCoolDownSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GuildCoolDownSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildCoolDownSyn& obj) { return obj.Size(); }
};
struct GuildCoolDownAck {
	enum { MSG_ID = 60054 }; 
	uint32_t	user_seq;
	int16_t	result;
	uint32_t	guild_seq;
	uint16_t	status;
	uint64_t	leave_time;
	GuildCoolDownAck()	{
		user_seq = 0;
		result = 0;
		guild_seq = 0;
		status = 0;
		leave_time = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint64_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &status, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		std::memcpy(*_buf_, &leave_time, sizeof(uint64_t)); (*_buf_) += sizeof(uint64_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&status, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&leave_time, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		return true;
	}
}; //GuildCoolDownAck
struct GuildCoolDownAck_Serializer {
	static bool Store(char** _buf_, const GuildCoolDownAck& obj) { return obj.Store(_buf_); }
	static bool Load(GuildCoolDownAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GuildCoolDownAck& obj) { return obj.Size(); }
};
struct SendGuildMailCheckSyn {
	enum { MSG_ID = 60055 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	uint32_t	recv_user_seq;
	uint64_t	item_seq;
	uint16_t	bag_type;
	uint32_t	gold;
	uint32_t	tax;
	std::string	msg;
	SendGuildMailCheckSyn()	{
		user_seq = 0;
		guild_seq = 0;
		recv_user_seq = 0;
		item_seq = 0;
		bag_type = 0;
		gold = 0;
		tax = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t); nSize += msg.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &recv_user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &item_seq, sizeof(uint64_t)); (*_buf_) += sizeof(uint64_t);
		std::memcpy(*_buf_, &bag_type, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		std::memcpy(*_buf_, &gold, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &tax, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		size_t msg_size = msg.length();
		std::memcpy(*_buf_, &msg_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, msg.c_str(), msg.length()); (*_buf_) += msg.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&recv_user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&item_seq, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&bag_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gold, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&tax, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t msg_length = 0; std::memcpy(&msg_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < msg_length) { return false; }
		msg.assign((char*)*_buf_, msg_length); (*_buf_) += msg_length; nSize -= msg_length;
		return true;
	}
}; //SendGuildMailCheckSyn
struct SendGuildMailCheckSyn_Serializer {
	static bool Store(char** _buf_, const SendGuildMailCheckSyn& obj) { return obj.Store(_buf_); }
	static bool Load(SendGuildMailCheckSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SendGuildMailCheckSyn& obj) { return obj.Size(); }
};
struct SendGuildMailCheckAck {
	enum { MSG_ID = 60056 }; 
	uint32_t	user_seq;
	int16_t	result;
	uint32_t	recv_user_seq;
	uint64_t	item_seq;
	uint16_t	bag_type;
	uint32_t	gold;
	uint32_t	tax;
	std::string	msg;
	SendGuildMailCheckAck()	{
		user_seq = 0;
		result = 0;
		recv_user_seq = 0;
		item_seq = 0;
		bag_type = 0;
		gold = 0;
		tax = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t); nSize += msg.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &result, sizeof(int16_t)); (*_buf_) += sizeof(int16_t);
		std::memcpy(*_buf_, &recv_user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &item_seq, sizeof(uint64_t)); (*_buf_) += sizeof(uint64_t);
		std::memcpy(*_buf_, &bag_type, sizeof(uint16_t)); (*_buf_) += sizeof(uint16_t);
		std::memcpy(*_buf_, &gold, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &tax, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		size_t msg_size = msg.length();
		std::memcpy(*_buf_, &msg_size, sizeof(int32_t)); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, msg.c_str(), msg.length()); (*_buf_) += msg.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&recv_user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&item_seq, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&bag_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gold, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&tax, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		uint32_t msg_length = 0; std::memcpy(&msg_length, *_buf_, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(nSize < msg_length) { return false; }
		msg.assign((char*)*_buf_, msg_length); (*_buf_) += msg_length; nSize -= msg_length;
		return true;
	}
}; //SendGuildMailCheckAck
struct SendGuildMailCheckAck_Serializer {
	static bool Store(char** _buf_, const SendGuildMailCheckAck& obj) { return obj.Store(_buf_); }
	static bool Load(SendGuildMailCheckAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SendGuildMailCheckAck& obj) { return obj.Size(); }
};
struct UpdateGuildLoginTimeSyn {
	enum { MSG_ID = 60057 }; 
	uint32_t	user_seq;
	uint32_t	guild_seq;
	UpdateGuildLoginTimeSyn()	{
		user_seq = 0;
		guild_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		std::memcpy(*_buf_, &user_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		std::memcpy(*_buf_, &guild_seq, sizeof(uint32_t)); (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&guild_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //UpdateGuildLoginTimeSyn
struct UpdateGuildLoginTimeSyn_Serializer {
	static bool Store(char** _buf_, const UpdateGuildLoginTimeSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateGuildLoginTimeSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateGuildLoginTimeSyn& obj) { return obj.Size(); }
};
#endif // __Guild_H__
